// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_MEMORY_REF_COUNTED_MEMORY_H_
#define BASE_MEMORY_REF_COUNTED_MEMORY_H_

#include <stddef.h>

#include <string>
#include <vector>

#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"

namespace base {

// A generic interface to memory. This object is reference counted because one
// of its two subclasses own the data they carry, and we need to have
// heterogeneous containers of these two types of memory.
class BASE_EXPORT RefCountedMemory
    : public base::RefCountedThreadSafe<RefCountedMemory> {
public:
    // Retrieves a pointer to the beginning of the data we point to. If the data
    // is empty, this will return NULL.
    virtual const unsigned char* front() const = 0;

    // Size of the memory pointed to.
    virtual size_t size() const = 0;

    // Returns true if |other| is byte for byte equal.
    bool Equals(const scoped_refptr<RefCountedMemory>& other) const;

    // Handy method to simplify calling front() with a reinterpret_cast.
    template <typename T>
    const T* front_as() const
    {
        return reinterpret_cast<const T*>(front());
    }

protected:
    friend class base::RefCountedThreadSafe<RefCountedMemory>;
    RefCountedMemory();
    virtual ~RefCountedMemory();
};

// An implementation of RefCountedMemory, where the ref counting does not
// matter.
class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory {
public:
    RefCountedStaticMemory()
        : data_(NULL)
        , length_(0)
    {
    }
    RefCountedStaticMemory(const void* data, size_t length)
        : data_(static_cast<const unsigned char*>(length ? data : NULL))
        , length_(length)
    {
    }

    // Overridden from RefCountedMemory:
    const unsigned char* front() const override;
    size_t size() const override;

private:
    ~RefCountedStaticMemory() override;

    const unsigned char* data_;
    size_t length_;

    DISALLOW_COPY_AND_ASSIGN(RefCountedStaticMemory);
};

// An implementation of RefCountedMemory, where we own the data in a vector.
class BASE_EXPORT RefCountedBytes : public RefCountedMemory {
public:
    RefCountedBytes();

    // Constructs a RefCountedBytes object by _copying_ from |initializer|.
    explicit RefCountedBytes(const std::vector<unsigned char>& initializer);

    // Constructs a RefCountedBytes object by copying |size| bytes from |p|.
    RefCountedBytes(const unsigned char* p, size_t size);

    // Constructs a RefCountedBytes object by performing a swap. (To non
    // destructively build a RefCountedBytes, use the constructor that takes a
    // vector.)
    static scoped_refptr<RefCountedBytes> TakeVector(
        std::vector<unsigned char>* to_destroy);

    // Overridden from RefCountedMemory:
    const unsigned char* front() const override;
    size_t size() const override;

    const std::vector<unsigned char>& data() const { return data_; }
    std::vector<unsigned char>& data() { return data_; }

private:
    ~RefCountedBytes() override;

    std::vector<unsigned char> data_;

    DISALLOW_COPY_AND_ASSIGN(RefCountedBytes);
};

// An implementation of RefCountedMemory, where the bytes are stored in an STL
// string. Use this if your data naturally arrives in that format.
class BASE_EXPORT RefCountedString : public RefCountedMemory {
public:
    RefCountedString();

    // Constructs a RefCountedString object by performing a swap. (To non
    // destructively build a RefCountedString, use the default constructor and
    // copy into object->data()).
    static scoped_refptr<RefCountedString> TakeString(std::string* to_destroy);

    // Overridden from RefCountedMemory:
    const unsigned char* front() const override;
    size_t size() const override;

    const std::string& data() const { return data_; }
    std::string& data() { return data_; }

private:
    ~RefCountedString() override;

    std::string data_;

    DISALLOW_COPY_AND_ASSIGN(RefCountedString);
};

} // namespace base

#endif // BASE_MEMORY_REF_COUNTED_MEMORY_H_
